\doxysection{x\+Task\+Create\+Static }
\hypertarget{group__x_task_create_static}{}\label{group__x_task_create_static}\index{xTaskCreateStatic@{xTaskCreateStatic}}
task. h 
\begin{DoxyPre}
TaskHandle\_t xTaskCreateStatic( TaskFunction\_t pvTaskCode,                              const char * const pcName,                              uint32\_t ulStackDepth,                              void *pvParameters,                              UBaseType\_t uxPriority,                              StackType\_t *pxStackBuffer,                              StaticTask\_t *pxTaskBuffer );\end{DoxyPre}


Create a new task and add it to the list of tasks that are ready to run.

Internally, within the Free\+RTOS implementation, tasks use two blocks of memory. The first block is used to hold the task\textquotesingle{}s data structures. The second block is used by the task as its stack. If a task is created using x\+Task\+Create() then both blocks of memory are automatically dynamically allocated inside the x\+Task\+Create() function. (see \href{http://www.freertos.org/a00111.html}{\texttt{http\+://www.\+freertos.\+org/a00111.\+html}}). If a task is created using x\+Task\+Create\+Static() then the application writer must provide the required memory. x\+Task\+Create\+Static() therefore allows a task to be created without using any dynamic memory allocation.


\begin{DoxyParams}{Parameters}
{\em pv\+Task\+Code} & Pointer to the task entry function. Tasks must be implemented to never return (i.\+e. continuous loop).\\
\hline
{\em pc\+Name} & A descriptive name for the task. This is mainly used to facilitate debugging. The maximum length of the string is defined by config\+MAX\+\_\+\+TASK\+\_\+\+NAME\+\_\+\+LEN in \doxylink{_free_r_t_o_s_config_8h_source}{Free\+RTOSConfig.\+h}.\\
\hline
{\em ul\+Stack\+Depth} & The size of the task stack specified as the number of variables the stack can hold -\/ not the number of bytes. For example, if the stack is 32-\/bits wide and ul\+Stack\+Depth is defined as 100 then 400 bytes will be allocated for stack storage.\\
\hline
{\em pv\+Parameters} & Pointer that will be used as the parameter for the task being created.\\
\hline
{\em ux\+Priority} & The priority at which the task will run.\\
\hline
{\em px\+Stack\+Buffer} & Must point to a Stack\+Type\+\_\+t array that has at least ul\+Stack\+Depth indexes -\/ the array will then be used as the task\textquotesingle{}s stack, removing the need for the stack to be allocated dynamically.\\
\hline
{\em px\+Task\+Buffer} & Must point to a variable of type Static\+Task\+\_\+t, which will then be used to hold the task\textquotesingle{}s data structures, removing the need for the memory to be allocated dynamically.\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
If neither px\+Stack\+Buffer or px\+Task\+Buffer are NULL, then the task will be created and a handle to the created task is returned. If either px\+Stack\+Buffer or px\+Task\+Buffer are NULL then the task will not be created and NULL is returned.
\end{DoxyReturn}
Example usage\+: 
\begin{DoxyPre}

   // Dimensions the buffer that the task being created will use as its stack.
   // NOTE:  This is the number of words the stack will hold, not the number of
   // bytes.  For example, if each stack item is 32-\/bits, and this is set to 100,
   // then 400 bytes (100 * 32-\/bits) will be allocated.
   \#define STACK\_SIZE 200

   // Structure that will hold the TCB of the task being created.
   StaticTask\_t xTaskBuffer;

   // Buffer that the task being created will use as its stack.  Note this is
   // an array of StackType\_t variables.  The size of StackType\_t is dependent on
   // the RTOS port.
   StackType\_t xStack[ STACK\_SIZE ];

   // Function that implements the task being created.
   void vTaskCode( void * pvParameters )
   \{
       // The parameter value is expected to be 1 as 1 is passed in the
       // pvParameters value in the call to xTaskCreateStatic().
       configASSERT( ( uint32\_t ) pvParameters == 1UL );

       for( ;; )
       \{
           // Task code goes here.
       \}
   \}

   // Function that creates a task.
   void vOtherFunction( void )
   \{
       TaskHandle\_t xHandle = NULL;

       // Create the task without using any dynamic memory allocation.
       xHandle = xTaskCreateStatic(
                     vTaskCode,       // Function that implements the task.
                     "{}NAME"{},          // Text name for the task.
                     STACK\_SIZE,      // Stack size in words, not bytes.
                     ( void * ) 1,    // Parameter passed into the task.
                     tskIDLE\_PRIORITY,// Priority at which the task is created.
                     xStack,          // Array to use as the task's stack.
                     \&xTaskBuffer );  // Variable to hold the task's data structure.

       // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
       // been created, and xHandle will be the task's handle.  Use the handle
       // to suspend the task.
       vTaskSuspend( xHandle );
   \}
  \end{DoxyPre}
 